package first.forHuaWei.机考;

import java.util.Scanner;

/**
 * 输入：
 *     2
 *     50,60 30,25
 *     120
 * 输出：
 *     55 只有第二个节点在转发，
 */
public class TransPackage {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 节点数k
        int k = Integer.parseInt(sc.nextLine());
        String[] str = sc.nextLine().split(" ");
        // k个节点转发能力数组
        int[][] capacity = new int[k + 1][2];
        int i = 1;
        for (String s : str) {
            String[] str1 = s.split(",");
            // 转发流量容量
            capacity[i][0] = Integer.parseInt(str1[0]);
            // 缓存流量容量
            capacity[i][1] = Integer.parseInt(str1[1]);
            i++;
        }
        // 初始流量
        int n = sc.nextInt();
        // DP状态：dp[i][0]为第一次从i节点发送的数据包，dp[i][1]为第二次从i发送过来的数据包数量
        int[][] dp = new int[k + 1][2];
        // base case
        dp[0][0] = n; // 第一次从0节点发送过来的数据包
        dp[0][1] = 0; // 第二次从0节点发送过来的数据包
        // dp[0]表示从0节点发送过来的数据包，capacity[i]表示第i个节点的转发和缓存能力
        dp[1] = dpFunction(dp[0], capacity[1]);
        // 初始化res，表示第1个节点的处理的转发加缓存的包数量与 n 比较的最小值
        int res = Math.min(dp[0][0] + dp[0][1], dp[1][0] + dp[1][1]);
        // 开始计算
        if (k == 0) {
            System.out.println(n);
        }
        if (k == 1) { // 只有一个节点，那么必然经过该节点处理
            System.out.println(res);
        } else {
            for (int j = 2; j <= k; j++) {
                // 上一个没坏，从上一个节点（j - 1）直接传到当前节点（j），没有故障
                int[] res1 = dpFunction(dp[j - 1], capacity[j]);
                // 上上一个节点（j - 2）传过来，上一个节点（j - 1）出现故障
                int[] res2 = dpFunction(dp[j - 2], capacity[j]);
                // 状态转移，选择值最小的一种传递方案
                dp[j] = res1[0] + res1[1] <= res2[0] + res2[1] ? res1 : res2;
            }
            // 最后一个节点坏掉或者正常情况比较较小值
            res = Math.min(dp[k][0] + dp[k][1], dp[k - 1][0] + dp[k - 1][1]);
            System.out.println(res);
        }
    }

    /**
     * 主要是去考虑最大和最小的情况
     *      最大不能超过转发窗口的大小
     *      最小就有情况了：
     *             第一：两个包的在第二次转发时 均使用 缓存中的 且没有超过 转发窗口
     *             第二：第一个转发窗口大于（第二个转发窗口+缓存），所以缓存中有剩余
     */
    private static int[] dpFunction(int[] pre, int[] capacity) {
        // 第一次发送的数据包数量，根据节点发送能力判断
        // pre[0]是上一个节点发送过来的大小，capacity[0]是当前节点的转发窗口大小
        int send1 = Math.min(pre[0], capacity[0]);
        // 第二次转发时：3个情况，比较这三个情况中的最小值
        // 情况1：比滑动窗口大的情况，看第二个节点的转发窗口大小，任何大于其的包都被丢弃了
        // 情况2：比滑动窗口小的情况，又分两种，
        // 情况2.1：当前节点的缓存没有满，那么当前节点的缓存就是第一次转发处理之后的量（pre[0] - capacity[0]），在加上上一个节点的缓存大小
        int send2 = Math.min(pre[0] - capacity[0] + pre[1], capacity[0]);
        // 情况2.2：当前节点缓存已经满了 加 上一个节点缓存数据包数量，capacity[1] + pre[1]
        send2 = Math.min(send2, capacity[1] + pre[1]);
        return new int[]{send1, send2};
    }
}
